home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume2 / languags / dasm20.1 < prev    next >
Text File  |  1988-10-26  |  50KB  |  2,605 lines
  1. Path: wucfua!wucs1!uunet!wyse!vsi1!ames!nrl-cmf!mailrus!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v02i027:  dasm - small systems cross assembler V2.0, Part01/03
  5. Message-ID: <9878@swan.ulowell.edu>
  6. Date: 26 Oct 88 17:20:25 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 2594
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: dillon@cory.berkeley.edu (Matt Dillon)
  12. Posting-number: Volume 2, Issue 27
  13. Archive-name: languages/dasm20.1
  14.  
  15. # This is a shell archive.  Remove anything before this line
  16. # then unpack it by saving it in a file and typing "sh file"
  17. # (Files unpacked will be owned by you and have default permissions).
  18. # This archive contains the following files:
  19. #    src/Makefile
  20. #    src/globals.c
  21. #    src/.edrc
  22. #    src/exp.c
  23. #    src/mne6303.c
  24. #    test/suite6502.asm
  25. #    test/suite68HC11.asm
  26. #    test/suite68705.asm
  27. #    test/suite6303.asm
  28. #    test/example.asm
  29. #
  30. if `test ! -d src`
  31. then
  32.   mkdir src
  33.   echo "mkdir src"
  34. fi
  35. if `test ! -s src/Makefile`
  36. then
  37. echo "writing src/Makefile"
  38. cat > src/Makefile << '\Rogue\Monster\'
  39.  
  40. #   DASM    -small systems cross assembler
  41. #   (c)Copyright 1988 Matthew Dillon, All Rights Reserved.
  42. #
  43. #   This Makefile is for AZTEC C on an Amiga.
  44. #
  45. #   ASSUMES UNIX OR AMIGA
  46.  
  47. DASM   = srcc:dasm
  48. FTOHEX = srcc:ftohex
  49.  
  50. CFLAGS= +L
  51.  
  52. SRC1= main.c
  53. SRC2= ops.c
  54. SRC3= globals.c
  55. SRC4= exp.c
  56. SRC5= symbols.c
  57. SRC6= mne6303.c
  58. SRC7= mne6502.c
  59. SRC8= mne68705.c
  60. SRC9= mne6811.c
  61.  
  62. OBJ1= vd0:main.o
  63. OBJ2= vd0:ops.o
  64. OBJ3= vd0:globals.o
  65. OBJ4= vd0:exp.o
  66. OBJ5= vd0:symbols.o
  67. OBJ6= vd0:mne6303.o
  68. OBJ7= vd0:mne6502.o
  69. OBJ8= vd0:mne68705.o
  70. OBJ9= vd0:mne6811.o
  71.  
  72. OBJS= $(OBJ1) $(OBJ2) $(OBJ3) $(OBJ4) $(OBJ5) $(OBJ6) $(OBJ7) $(OBJ8) $(OBJ9)
  73. SRCS= $(SRC1) $(SRC2) $(SRC3) $(SRC4) $(SRC5) $(SRC6) $(SRC7) $(SRC8) $(SRC9)
  74.  
  75. all: $(DASM) $(FTOHEX)
  76.  
  77. $(DASM): $(OBJS)
  78.     ln -W +Q $(OBJS) -lsup32 -lc32 -O $(DASM)
  79.  
  80. $(FTOHEX): ftohex.c
  81.     cc $(CFLAGS) ftohex.c -o T:ftohex.o
  82.     ln +Q T:ftohex.o -lsup32 -lc32 -O $(FTOHEX)
  83.     delete T:ftohex.o
  84.  
  85. example:
  86.     dasm example.asm -oram:example.out -lram:example.list -f2
  87.     ftohex 2 ram:example.out ram:example.hex
  88.  
  89. $(OBJ1):    $(SRC1)
  90.     cc $(CFLAGS) $(SRC1) -o $(OBJ1)
  91. $(OBJ2):    $(SRC2)
  92.     cc $(CFLAGS) $(SRC2) -o $(OBJ2)
  93. $(OBJ3):    $(SRC3)
  94.     cc $(CFLAGS) $(SRC3) -o $(OBJ3)
  95. $(OBJ4):    $(SRC4)
  96.     cc $(CFLAGS) $(SRC4) -o $(OBJ4)
  97. $(OBJ5):    $(SRC5)
  98.     cc $(CFLAGS) $(SRC5) -o $(OBJ5)
  99. $(OBJ6):    $(SRC6)
  100.     cc $(CFLAGS) $(SRC6) -o $(OBJ6)
  101. $(OBJ7):    $(SRC7)
  102.     cc $(CFLAGS) $(SRC7) -o $(OBJ7)
  103. $(OBJ8):    $(SRC8)
  104.     cc $(CFLAGS) $(SRC8) -o $(OBJ8)
  105. $(OBJ9):    $(SRC9)
  106.     cc $(CFLAGS) $(SRC9) -o $(OBJ9)
  107.  
  108. \Rogue\Monster\
  109. else
  110.   echo "will not over write src/Makefile"
  111. fi
  112. if [ `wc -c src/Makefile | awk '{printf $1}'` -ne 1537 ]
  113. then
  114. echo `wc -c src/Makefile | awk '{print "Got " $1 ", Expected " 1537}'`
  115. fi
  116. if `test ! -s src/globals.c`
  117. then
  118. echo "writing src/globals.c"
  119. cat > src/globals.c << '\Rogue\Monster\'
  120.  
  121. /*
  122.  *  GLOBALS.C
  123.  *
  124.  *  (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  125.  *
  126.  */
  127.  
  128. #include "asm.h"
  129.  
  130. extern void v_list(), v_include(), v_seg(), v_dc(), v_ds(),
  131.         v_org(), v_rorg(), v_rend(), v_align(), v_subroutine(),
  132.         v_equ(), v_eqm(), v_set(), v_macro(), v_endm(), v_mexit(),
  133.         v_ifconst(), v_ifnconst(), v_if(), v_else(),
  134.         v_endif(), v_repeat(), v_repend(), v_err(), v_hex(), v_trace();
  135. extern void v_end(), v_echo(), v_processor();
  136.  
  137.  
  138. SYMBOL    *SHash[SHASHSIZE];  /*    symbol hash table   */
  139. MNE    *MHash[MHASHSIZE];  /*    mnemonic hash table */
  140. INCFILE *Incfile;        /*    include file stack  */
  141. REPLOOP *Reploop;        /*    repeat loop stack   */
  142. SEGMENT *Seglist;        /*    segment list        */
  143. SEGMENT *Csegment;        /*    current segment     */
  144. IFSTACK *Ifstack;        /*    IF/ELSE/ENDIF stack */
  145. ubyte    *Av[256];        /*    up to 256 arguments */
  146. ubyte    Avbuf[512];
  147. ubyte    MsbOrder = 1;
  148. uword    Mnext;
  149. char    Inclevel;
  150. uword    Mlevel;
  151. ulong    Localindex;        /*    to generate local variables */
  152. ulong    Lastlocalindex;
  153. ulong    Processor;
  154. ubyte    Xdebug, Xtrace;
  155. ubyte    Outputformat;
  156. ulong    Redo, Redo_why;
  157. ulong    Redo_eval;        /*    infinite loop detection only    */
  158. char    ListMode = 1;
  159. ulong    CheckSum;        /*    output data checksum        */
  160.  
  161.  
  162. ubyte    F_format = 1;
  163. ubyte    F_verbose;
  164. char    *F_outfile = "a.out";
  165. char    *F_listfile;
  166. char    *F_symfile;
  167. char    *F_temppath = "ram:";
  168. FILE    *FI_listfile;
  169. FILE    *FI_temp;
  170. ubyte    Fisclear;
  171. ulong    Plab, Pflags;
  172.  
  173. uword    Adrbytes[]  = { 1, 2, 3, 2, 2, 2, 3, 3, 3, 2, 2, 2, 3, 1, 1, 2, 3 };
  174. uword    Cvt[]        = { 0, 2, 0, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 4, 5, 0, 0 };
  175. uword    Opsize[]    = { 0, 1, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 2, 0, 0, 1, 1 };
  176.  
  177. MNE Ops[] = {
  178.     { NULL, v_list    , "list",           0,      0 },
  179.     { NULL, v_include , "include",        0,      0 },
  180.     { NULL, v_seg     , "seg",            0,      0 },
  181.     { NULL, v_hex     , "hex",            0,      0 },
  182.     { NULL, v_err     , "err",            0,      0 },
  183.     { NULL, v_dc      , "dc",             0,      0 },
  184.     { NULL, v_ds      , "ds",             0,      0 },
  185.     { NULL, v_dc      , "dv",             0,      0 },
  186.     { NULL, v_end     , "end",            0,      0 },
  187.     { NULL, v_trace   , "trace",          0,      0 },
  188.     { NULL, v_org     , "org",            0,      0 },
  189.     { NULL, v_rorg    , "rorg",           0,      0 },
  190.     { NULL, v_rend    , "rend",           0,      0 },
  191.     { NULL, v_align   , "align",          0,      0 },
  192.     { NULL, v_subroutine, "subroutine",   0,      0 },
  193.     { NULL, v_equ     , "equ",            0,      0 },
  194.     { NULL, v_eqm     , "eqm",            0,      0 },
  195.     { NULL, v_set     , "set",            0,      0 },
  196.     { NULL, v_macro   , "mac",            MF_IF,  0 },
  197.     { NULL, v_endm    , "endm",           0,      0 },
  198.     { NULL, v_mexit   , "mexit",          0,      0 },
  199.     { NULL, v_ifconst , "ifconst",        MF_IF,  0 },
  200.     { NULL, v_ifnconst, "ifnconst",       MF_IF,  0 },
  201.     { NULL, v_if      , "if",             MF_IF,  0 },
  202.     { NULL, v_else    , "else",           MF_IF,  0 },
  203.     { NULL, v_endif   , "endif",          MF_IF,  0 },
  204.     { NULL, v_endif   , "eif",            MF_IF,  0 },
  205.     { NULL, v_repeat  , "repeat",         MF_IF,  0 },
  206.     { NULL, v_repend  , "repend",         MF_IF,  0 },
  207.     { NULL, v_echo    , "echo",           0,      0 },
  208.     { NULL, v_processor,"processor",      0,      0 },
  209.     NULL
  210. };
  211.  
  212. \Rogue\Monster\
  213. else
  214.   echo "will not over write src/globals.c"
  215. fi
  216. if [ `wc -c src/globals.c | awk '{printf $1}'` -ne 3363 ]
  217. then
  218. echo `wc -c src/globals.c | awk '{print "Got " $1 ", Expected " 3363}'`
  219. fi
  220. if `test ! -s src/.edrc`
  221. then
  222. echo "writing src/.edrc"
  223. cat > src/.edrc << '\Rogue\Monster\'
  224. map s-f9 (saveas vd0:dasm/\$filename)
  225. \Rogue\Monster\
  226. else
  227.   echo "will not over write src/.edrc"
  228. fi
  229. if [ `wc -c src/.edrc | awk '{printf $1}'` -ne 38 ]
  230. then
  231. echo `wc -c src/.edrc | awk '{print "Got " $1 ", Expected " 38}'`
  232. fi
  233. if `test ! -s src/exp.c`
  234. then
  235. echo "writing src/exp.c"
  236. cat > src/exp.c << '\Rogue\Monster\'
  237.  
  238. /*
  239.  *  EXP.C
  240.  *
  241.  *  (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  242.  *
  243.  *  Handle expression evaluation and addressing mode decode.
  244.  *
  245.  *  NOTE! If you use the string field in an expression you must clear
  246.  *  the SYM_MACRO and SYM_STRING bits in the flags before calling
  247.  *  freesymbollist()!
  248.  */
  249.  
  250. #include "asm.h"
  251.  
  252. extern void doop(), evaltop(), stackarg();
  253. extern void op_mult(), op_div(), op_mod(), op_add(), op_sub(),
  254.         op_shiftleft(), op_shiftright(), op_greater(), op_greatereq(),
  255.         op_smaller(), op_smallereq(), op_eqeq(), op_noteq(),
  256.         op_andand(), op_oror(), op_xor(), op_and(), op_or(),
  257.         op_negate(), op_invert(), op_not();
  258. extern void op_takelsb(), op_takemsb(), op_question();
  259.  
  260.  
  261. extern ubyte *pushsymbol(), *pushstr(), *pushbin(), *pushoct(),
  262.         *pushdec(), *pushhex(), *pushchar();
  263.  
  264. extern short alphanum();
  265.  
  266. /*
  267.  *  evaluate an expression.  Figure out the addressing mode:
  268.  *
  269.  *            implied
  270.  *    #val        immediate
  271.  *    val        zero page or absolute
  272.  *    val,x        zero,x or absolute,x
  273.  *    val,y        zero,y or absolute,y
  274.  *    (val)       indirect
  275.  *    (val,x)     zero indirect x
  276.  *    (val),y     zero indirect y
  277.  *
  278.  *    exp, exp,.. LIST of expressions
  279.  *
  280.  *  an absolute may be returned as zero page
  281.  *  a relative may be returned as zero page or absolute
  282.  *
  283.  *  unary:  - ~ ! < >
  284.  *  binary: (^)(* / %)(+ -)(>> <<)(& |)(`)(&& ||)(== != < > <= >=)
  285.  *
  286.  *  values: symbol, octal, decimal, $hex, %binary, 'c "str"
  287.  *
  288.  */
  289.  
  290. #define MAXOPS    32
  291. #define MAXARGS 64
  292.  
  293. ubyte Argflags[MAXARGS];
  294. long  Argstack[MAXARGS];
  295. ubyte *Argstring[MAXARGS];
  296. short Oppri[MAXOPS];
  297. void  (*Opdis[MAXOPS])();
  298.  
  299. uword    Argi, Opi, Lastwasop;
  300. uword    Argibase, Opibase;
  301.  
  302. SYMBOL *
  303. eval(str)
  304. register char *str;
  305. {
  306.     register SYMBOL *base, *cur;
  307.     uword oldargibase = Argibase;
  308.     uword oldopibase = Opibase;
  309.     uword scr;
  310.  
  311.     Argibase = Argi;
  312.     Opibase = Opi;
  313.     Lastwasop = 1;
  314.     base = cur = allocsymbol();
  315.  
  316.     while (*str) {
  317.     if (Xdebug)
  318.         printf("char '%c'\n", *str);
  319.     switch(*str) {
  320.     case ' ':
  321.     case '\n':
  322.         ++str;
  323.         break;
  324.     case '~':
  325.         if (Lastwasop)
  326.         doop(op_invert, 128);
  327.         else
  328.         asmerr(0,0);
  329.         ++str;
  330.         break;
  331.     case '*':
  332.         doop(op_mult, 20);
  333.         ++str;
  334.         break;
  335.     case '/':
  336.         doop(op_div, 20);
  337.         ++str;
  338.         break;
  339.     case '%':
  340.         if (Lastwasop) {
  341.         str = (char *)pushbin(str+1);
  342.         } else {
  343.         doop(op_mod, 20);
  344.         ++str;
  345.         }
  346.         break;
  347.     case '?':   /*  10      */
  348.         doop(op_question, 10);
  349.         ++str;
  350.         break;
  351.     case '+':   /*  19      */
  352.         doop(op_add, 19);
  353.         ++str;
  354.         break;
  355.     case '-':   /*  19: -   (or - unary)        */
  356.         if (Lastwasop) {
  357.         doop(op_negate, 128);
  358.         } else {
  359.         doop(op_sub, 19);
  360.         }
  361.         ++str;
  362.         break;
  363.     case '>':   /*  18: >> <<  17: > >= <= <    */
  364.         if (Lastwasop) {
  365.         doop(op_takemsb, 128);
  366.         ++str;
  367.         break;
  368.         }
  369.  
  370.         if (str[1] == '>') {
  371.         doop(op_shiftright, 18);
  372.         ++str;
  373.         } else if (str[1] == '=') {
  374.         doop(op_greatereq, 17);
  375.         ++str;
  376.         } else {
  377.         doop(op_greater, 17);
  378.         }
  379.         ++str;
  380.         break;
  381.     case '<':
  382.         if (Lastwasop) {
  383.         doop(op_takelsb, 128);
  384.         ++str;
  385.         break;
  386.         }
  387.         if (str[1] == '<') {
  388.         doop(op_shiftleft, 18);
  389.         ++str;
  390.         } else if (str[1] == '=') {
  391.         doop(op_smallereq, 17);
  392.         ++str;
  393.         } else {
  394.         doop(op_smaller, 17);
  395.         }
  396.         ++str;
  397.         break;
  398.     case '=':   /*  16: ==  (= same as ==)      */
  399.         if (str[1] == '=')
  400.         ++str;
  401.         doop(op_eqeq, 16);
  402.         ++str;
  403.         break;
  404.     case '!':   /*  16: !=                      */
  405.         if (Lastwasop) {
  406.         doop(op_not, 128);
  407.         } else {
  408.         doop(op_noteq, 16);
  409.         ++str;
  410.         }
  411.         ++str;
  412.         break;
  413.     case '&':   /*  15: &   12: &&              */
  414.         if (str[1] == '&') {
  415.         doop(op_andand, 12);
  416.         ++str;
  417.         } else {
  418.         doop(op_and, 15);
  419.         }
  420.         ++str;
  421.         break;
  422.     case '^':   /*  14: ^                       */
  423.         doop(op_xor, 14);
  424.         ++str;
  425.         break;
  426.     case '|':   /*  13: |   11: ||              */
  427.         if (str[1] == '|') {
  428.         doop(op_oror, 11);
  429.         ++str;
  430.         } else {
  431.         doop(op_or, 13);
  432.         }
  433.         ++str;
  434.         break;
  435.     case '[':   /*  eventually an argument      */
  436.         if (Opi == MAXOPS)
  437.         puts("too many ops");
  438.         else
  439.         Oppri[Opi++] = 0;
  440.         ++str;
  441.         break;
  442.     case ']':
  443.         while(Opi != Opibase && Oppri[Opi-1])
  444.         evaltop();
  445.         if (Opi != Opibase)
  446.         --Opi;
  447.         ++str;
  448.         if (Argi == Argibase) {
  449.         puts("']' error, no arg on stack");
  450.         break;
  451.         }
  452.         if (*str == 'd') {  /*  STRING CONVERSION   */
  453.         char buf[32];
  454.         ++str;
  455.         if (Argflags[Argi-1] == 0) {
  456.             sprintf(buf,"%ld",Argstack[Argi-1]);
  457.             Argstring[Argi-1] = strcpy(malloc(strlen(buf)+1),buf);
  458.         }
  459.         }
  460.         break;
  461.     case '#':
  462.         cur->addrmode = AM_IMM8;
  463.         ++str;
  464.         break;
  465.     case '(':
  466.         cur->addrmode = AM_INDWORD;
  467.         ++str;
  468.         break;
  469.     case ')':
  470.         if (cur->addrmode == AM_INDWORD && str[1] == ',' && (str[2]|0x20) == 'y') {
  471.         cur->addrmode = AM_INDBYTEY;
  472.         str += 2;
  473.         }
  474.         ++str;
  475.         break;
  476.     case ',':
  477.         while(Opi != Opibase)
  478.         evaltop();
  479.         Lastwasop = 1;
  480.         scr = str[1]|0x20;    /* to lower case */
  481.         if (cur->addrmode == AM_INDWORD && scr == 'x' && !alphanum(str[2])) {
  482.         cur->addrmode = AM_INDBYTEX;
  483.         ++str;
  484.         } else if (scr == 'x' && !alphanum(str[2])) {
  485.         cur->addrmode = AM_0X;
  486.         ++str;
  487.         } else if (scr == 'y' && !alphanum(str[2])) {
  488.         cur->addrmode = AM_0Y;
  489.         ++str;
  490.         } else {
  491.         register SYMBOL *new = allocsymbol();
  492.         cur->next = new;
  493.         --Argi;
  494.         if (Argi < Argibase)
  495.             asmerr(0,0);
  496.         if (Argi > Argibase)
  497.             asmerr(0,0);
  498.         cur->value = Argstack[Argi];
  499.         cur->flags = Argflags[Argi];
  500.         if (cur->string= (ubyte *)Argstring[Argi]) {
  501.             cur->flags |= SYM_STRING;
  502.             if (Xdebug)
  503.             printf("STRING: %s\n", cur->string);
  504.         }
  505.         cur = new;
  506.         }
  507.         ++str;
  508.         break;
  509.     case '$':
  510.         str = (char *)pushhex(str+1);
  511.         break;
  512.     case '\'':
  513.         str = (char *)pushchar(str+1);
  514.         break;
  515.     case '\"':
  516.         str = (char *)pushstr(str+1);
  517.         break;
  518.     default:
  519.         if (*str == '0')
  520.         str = (char *)pushoct(str);
  521.         else {
  522.         if (*str > '0' && *str <= '9')
  523.             str = (char *)pushdec(str);
  524.         else
  525.             str = (char *)pushsymbol(str);
  526.         }
  527.         break;
  528.     }
  529.     }
  530.     while(Opi != Opibase)
  531.     evaltop();
  532.     if (Argi != Argibase) {
  533.     short add = 0;
  534.     --Argi;
  535.     cur->value = Argstack[Argi];
  536.     cur->flags = Argflags[Argi];
  537.     if (cur->string= (ubyte *)Argstring[Argi]) {
  538.         cur->flags |= SYM_STRING;
  539.         if (Xdebug)
  540.         printf("STRING: %s\n", cur->string);
  541.     }
  542.     if (base->addrmode == 0)
  543.         base->addrmode = AM_BYTEADR;
  544.     }
  545.     if (Argi != Argibase || Opi != Opibase)
  546.     asmerr(0,0);
  547.     Argi = Argibase;
  548.     Opi  = Opibase;
  549.     Argibase = oldargibase;
  550.     Opibase = oldopibase;
  551.     return(base);
  552. }
  553.  
  554. short
  555. alphanum(c)
  556. {
  557.     return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'));
  558. }
  559.  
  560. void
  561. evaltop()
  562. {
  563.     if (Xdebug)
  564.     printf("evaltop @(A,O) %d %d\n", Argi, Opi);
  565.     if (Opi <= Opibase) {
  566.     asmerr(0,0);
  567.     Opi = Opibase;
  568.     return;
  569.     }
  570.     --Opi;
  571.     if (Oppri[Opi] == 128) {
  572.     if (Argi < Argibase + 1) {
  573.         asmerr(0,0);
  574.         Argi = Argibase;
  575.         return;
  576.     }
  577.     --Argi;
  578.     (*Opdis[Opi])(Argstack[Argi], Argflags[Argi]);
  579.     } else {
  580.     if (Argi < Argibase + 2) {
  581.         asmerr(0,0);
  582.         Argi = Argibase;
  583.         return;
  584.     }
  585.     Argi -= 2;
  586.     (*Opdis[Opi])(Argstack[Argi], Argstack[Argi+1], Argflags[Argi], Argflags[Argi+1]);
  587.     }
  588. }
  589.  
  590. void
  591. stackarg(val, flags, ptr1)
  592. long val;
  593. short flags;
  594. ubyte *ptr1;
  595. {
  596.     ubyte *str = NULL;
  597.  
  598.     if (Xdebug)
  599.     printf("stackarg %ld (@%d)\n", val, Argi);
  600.     Lastwasop = 0;
  601.     if (flags & SYM_STRING) {
  602.     register ubyte *ptr = ptr1;
  603.     register ubyte *new;
  604.     register uword len;
  605.     val = len = 0;
  606.     while (*ptr && *ptr != '\"') {
  607.         val = (val << 8) | *ptr;
  608.         ++ptr;
  609.         ++len;
  610.     }
  611.     new = malloc(len + 1);
  612.     bmov(ptr1, new, len);
  613.     new[len] = 0;
  614.     flags &= ~SYM_STRING;
  615.     str = new;
  616.     }
  617.     Argstack[Argi] = val;
  618.     Argstring[Argi] = str;
  619.     Argflags[Argi] = flags;
  620.     if (++Argi == MAXARGS) {
  621.     puts("stackarg: maxargs stacked");
  622.     Argi = Argibase;
  623.     }
  624.     while (Opi != Opibase && Oppri[Opi-1] == 128)
  625.     evaltop();
  626. }
  627.  
  628. void
  629. doop(func, pri)
  630. void (*func)();
  631. {
  632.     if (Xdebug)
  633.     puts("doop");
  634.     Lastwasop = 1;
  635.     if (Opi == Opibase || pri == 128) {
  636.     if (Xdebug)
  637.         printf("doop @ %d unary\n", Opi);
  638.     Opdis[Opi] = func;
  639.     Oppri[Opi] = pri;
  640.     ++Opi;
  641.     return;
  642.     }
  643.     while (Opi != Opibase && Oppri[Opi-1] && pri <= Oppri[Opi-1])
  644.     evaltop();
  645.     if (Xdebug)
  646.     printf("doop @ %d\n", Opi);
  647.     Opdis[Opi] = func;
  648.     Oppri[Opi] = pri;
  649.     ++Opi;
  650.     if (Opi == MAXOPS) {
  651.     puts("doop: too many operators");
  652.     Opi = Opibase;
  653.     }
  654.     return;
  655. }
  656.  
  657. void
  658. op_takelsb(v1, f1)
  659. long v1;
  660. {
  661.     stackarg(v1 & 0xFFL, f1);
  662. }
  663.  
  664. void
  665. op_takemsb(v1, f1)
  666. long v1;
  667. {
  668.     stackarg((v1 >> 8) & 0xFF, f1);
  669. }
  670.  
  671. void
  672. op_negate(v1, f1)
  673. long v1;
  674. {
  675.     stackarg(-v1, f1);
  676. }
  677.  
  678. void
  679. op_invert(v1, f1)
  680. long v1;
  681. {
  682.     stackarg(~v1, f1);
  683. }
  684.  
  685. void
  686. op_not(v1, f1)
  687. long v1;
  688. {
  689.     stackarg((long)!v1, f1);
  690. }
  691.  
  692. void
  693. op_mult(v1, v2, f1, f2)
  694. long v1, v2;
  695. {
  696.     stackarg(v1 * v2, f1|f2);
  697. }
  698.  
  699. void
  700. op_div(v1, v2, f1, f2)
  701. long v1, v2;
  702. {
  703.     if (f1|f2) {
  704.     stackarg(0L, f1|f2);
  705.     return;
  706.     }
  707.     if (v2 == 0) {
  708.     puts("division by zero");
  709.     stackarg(0L, 0);
  710.     } else {
  711.     stackarg(v1 / v2, 0);
  712.     }
  713. }
  714.  
  715. void
  716. op_mod(v1, v2, f1, f2)
  717. long v1, v2;
  718. {
  719.     if (f1|f2) {
  720.     stackarg(0L, f1|f2);
  721.     return;
  722.     }
  723.     if (v2 == 0)
  724.     stackarg(v1, 0);
  725.     else
  726.     stackarg(v1 % v2, 0);
  727. }
  728.  
  729. void
  730. op_question(v1, v2, f1, f2)
  731. long v1, v2;
  732. {
  733.     if (f1)
  734.     stackarg(0L, f1);
  735.     else
  736.     stackarg((long)((v1) ? v2 : 0), ((v1) ? f2 : 0));
  737. }
  738.  
  739. void
  740. op_add(v1, v2, f1, f2)
  741. long v1, v2;
  742. {
  743.     stackarg(v1 + v2, f1|f2);
  744. }
  745.  
  746. void
  747. op_sub(v1, v2, f1, f2)
  748. long v1, v2;
  749. {
  750.     stackarg(v1 - v2, f1|f2);
  751. }
  752.  
  753. void
  754. op_shiftright(v1, v2, f1, f2)
  755. long v1, v2;
  756. {
  757.     if (f1|f2)
  758.     stackarg(0L, f1|f2);
  759.     else
  760.     stackarg((long)(v1 >> v2), 0);
  761. }
  762.  
  763. void
  764. op_shiftleft(v1, v2, f1, f2)
  765. long v1, v2;
  766. {
  767.     if (f1|f2)
  768.     stackarg(0L, f1|f2);
  769.     else
  770.     stackarg((long)(v1 << v2), 0);
  771. }
  772.  
  773. void
  774. op_greater(v1, v2, f1, f2)
  775. long v1, v2;
  776. {
  777.     stackarg((long)(v1 > v2), f1|f2);
  778. }
  779.  
  780. void
  781. op_greatereq(v1, v2, f1, f2)
  782. long v1, v2;
  783. {
  784.     stackarg((long)(v1 >= v2), f1|f2);
  785. }
  786.  
  787. void
  788. op_smaller(v1, v2, f1, f2)
  789. long v1, v2;
  790. {
  791.     stackarg((long)(v1 < v2), f1|f2);
  792. }
  793.  
  794. void
  795. op_smallereq(v1, v2, f1, f2)
  796. long v1, v2;
  797. {
  798.     stackarg((long)(v1 <= v2), f1|f2);
  799. }
  800.  
  801. void
  802. op_eqeq(v1, v2, f1, f2)
  803. long v1, v2;
  804. {
  805.     stackarg((long)(v1 == v2), f1|f2);
  806. }
  807.  
  808. void
  809. op_noteq(v1, v2, f1, f2)
  810. long v1, v2;
  811. {
  812.     stackarg((long)(v1 != v2), f1|f2);
  813. }
  814.  
  815. void
  816. op_andand(v1, v2, f1, f2)
  817. long v1, v2;
  818. {
  819.     if ((!f1 && !v1) || (!f2 && !v2)) {
  820.     stackarg(0L, 0);
  821.     return;
  822.     }
  823.     stackarg(1L, f1|f2);
  824. }
  825.  
  826. void
  827. op_oror(v1, v2, f1, f2)
  828. long v1, v2;
  829. {
  830.     if ((!f1 && v1) || (!f2 && v2)) {
  831.     stackarg(1L, 0);
  832.     return;
  833.     }
  834.     stackarg(0L, f1|f2);
  835. }
  836.  
  837. void
  838. op_xor(v1, v2, f1, f2)
  839. long v1, v2;
  840. {
  841.     stackarg(v1^v2, f1|f2);
  842. }
  843.  
  844. void
  845. op_and(v1, v2, f1, f2)
  846. long v1, v2;
  847. {
  848.     stackarg(v1&v2, f1|f2);
  849. }
  850.  
  851. void
  852. op_or(v1, v2, f1, f2)
  853. long v1, v2;
  854. {
  855.     stackarg(v1|v2, f1|f2);
  856. }
  857.  
  858. ubyte *
  859. pushchar(str)
  860. char *str;
  861. {
  862.     if (*str) {
  863.     stackarg((long)*str, 0);
  864.     ++str;
  865.     } else {
  866.     stackarg((long)' ', 0);
  867.     }
  868.     return((ubyte *)str);
  869. }
  870.  
  871. ubyte *
  872. pushhex(str)
  873. char *str;
  874. {
  875.     register long val = 0;
  876.     for (;; ++str) {
  877.     if (*str >= '0' && *str <= '9') {
  878.         val = (val << 4) + (*str - '0');
  879.         continue;
  880.     }
  881.     if ((*str >= 'a' && *str <= 'f') || (*str >= 'A' && *str <= 'F')) {
  882.         val = (val << 4) + ((*str&0x1F) + 9);
  883.         continue;
  884.     }
  885.     break;
  886.     }
  887.     stackarg(val, 0);
  888.     return((ubyte *)str);
  889. }
  890.  
  891. ubyte *
  892. pushoct(str)
  893. char *str;
  894. {
  895.     register long val = 0;
  896.     while (*str >= '0' && *str <= '7') {
  897.     val = (val << 3) + (*str - '0');
  898.     ++str;
  899.     }
  900.     stackarg(val, 0);
  901.     return((ubyte *)str);
  902. }
  903.  
  904. ubyte *
  905. pushdec(str)
  906. char *str;
  907. {
  908.     register long val = 0;
  909.     while (*str >= '0' && *str <= '9') {
  910.     val = (val * 10) + (*str - '0');
  911.     ++str;
  912.     }
  913.     stackarg(val, 0);
  914.     return((ubyte *)str);
  915. }
  916.  
  917. ubyte *
  918. pushbin(str)
  919. char *str;
  920. {
  921.     register long val = 0;
  922.     while (*str == '0' || *str == '1') {
  923.     val = (val << 1) | (*str - '0');
  924.     ++str;
  925.     }
  926.     stackarg(val, 0);
  927.     return((ubyte *)str);
  928. }
  929.  
  930. ubyte *
  931. pushstr(str)
  932. char *str;
  933. {
  934.     stackarg(0L, SYM_STRING, str);
  935.     while (*str && *str != '\"')
  936.     ++str;
  937.     if (*str == '\"')
  938.     ++str;
  939.     return((ubyte *)str);
  940. }
  941.  
  942. ubyte *
  943. pushsymbol(str)
  944. ubyte *str;
  945. {
  946.     register SYMBOL *sym;
  947.     register ubyte *ptr;
  948.     ubyte macro = 0;
  949.  
  950.     for (ptr = str;
  951.     *ptr == '_' ||
  952.     *ptr == '.' ||
  953.     (*ptr >= 'a' && *ptr <= 'z') ||
  954.     (*ptr >= 'A' && *ptr <= 'Z') ||
  955.     (*ptr >= '0' && *ptr <= '9');
  956.     ++ptr
  957.     );
  958.     if (ptr == str) {
  959.     asmerr(9,0);
  960.     printf("char = '%c' %d (-1: %d)\n", *str, *str, *(str-1));
  961.     if (F_listfile)
  962.         fprintf(FI_listfile, "char = '%c' code %d\n", *str, *str);
  963.     return((ubyte *)str+1);
  964.     }
  965.     if (sym = findsymbol(str, ptr - str)) {
  966.     if (sym->flags & SYM_UNKNOWN)
  967.         ++Redo_eval;
  968.     if (sym->flags & SYM_MACRO) {
  969.         macro = 1;
  970.         sym = eval(sym->string);
  971.     }
  972.     if (sym->flags & SYM_STRING)
  973.         stackarg(0L, SYM_STRING, sym->string);
  974.     else
  975.         stackarg(sym->value, sym->flags & SYM_UNKNOWN);
  976.     sym->flags |= SYM_REF|SYM_MASREF;
  977.     if (macro)
  978.         freesymbollist(sym);
  979.     } else {
  980.     stackarg(0L, SYM_UNKNOWN);
  981.     sym = createsymbol(str, ptr - str);
  982.     sym->flags = SYM_REF|SYM_MASREF|SYM_UNKNOWN;
  983.     ++Redo_eval;
  984.     }
  985.     return(ptr);
  986. }
  987.  
  988. \Rogue\Monster\
  989. else
  990.   echo "will not over write src/exp.c"
  991. fi
  992. if [ `wc -c src/exp.c | awk '{printf $1}'` -ne 13218 ]
  993. then
  994. echo `wc -c src/exp.c | awk '{print "Got " $1 ", Expected " 13218}'`
  995. fi
  996. if `test ! -s src/mne6303.c`
  997. then
  998. echo "writing src/mne6303.c"
  999. cat > src/mne6303.c << '\Rogue\Monster\'
  1000.  
  1001. /*
  1002.  *  MNE6303.C
  1003.  *
  1004.  *  (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  1005.  */
  1006.  
  1007. #include "asm.h"
  1008.  
  1009. extern void v_mnemonic();
  1010.  
  1011. /*
  1012.  *  IMP IMM8 IMM16 BYTE BYTEX BYTEY WORD WORDX WORDY REL (,x) (),y (WORD)
  1013.  *   0     1    2     3     4    5    6       7     8    9   10   11    12
  1014.  *
  1015.  *  0,x 0,y BIT BITBRA
  1016.  *   13  14  15   16
  1017.  */
  1018.  
  1019. MNE Mne6803[] = {
  1020.     { NULL, v_mnemonic, "aba", 0,   AF_IMP,
  1021.     { 0x1B }},
  1022.     { NULL, v_mnemonic, "abx", 0,   AF_IMP,
  1023.     { 0x3A }},
  1024.     { NULL, v_mnemonic, "adca", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1025.     { 0x89, 0x99, 0xA9, 0xB9 }},
  1026.     { NULL, v_mnemonic, "adcb", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1027.     { 0xC9, 0xD9, 0xE9, 0xF9 }},
  1028.     { NULL, v_mnemonic, "adda", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1029.     { 0x8B, 0x9B, 0xAB, 0xBB }},
  1030.     { NULL, v_mnemonic, "addb", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1031.     { 0xCB, 0xDB, 0xEB, 0xFB }},
  1032.     { NULL, v_mnemonic, "addd", 0,  AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1033.     { 0xC3, 0xD3, 0xE3, 0xF3 }},
  1034.     { NULL, v_mnemonic, "anda", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1035.     { 0x84, 0x94, 0xA4, 0xB4 }},
  1036.     { NULL, v_mnemonic, "andb", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1037.     { 0xC4, 0xD4, 0xE4, 0xF4 }},
  1038.     { NULL, v_mnemonic, "bita", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1039.     { 0x85, 0x95, 0xA5, 0xB5 }},
  1040.     { NULL, v_mnemonic, "bitb", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1041.     { 0xC5, 0xD5, 0xE5, 0xF5 }},
  1042.     { NULL, v_mnemonic, "bra", 0,   AF_REL, { 0x20 }},
  1043.     { NULL, v_mnemonic, "brn", 0,   AF_REL, { 0x21 }},
  1044.     { NULL, v_mnemonic, "bcc", 0,   AF_REL, { 0x24 }},
  1045.     { NULL, v_mnemonic, "bhs", 0,   AF_REL, { 0x24 }},
  1046.     { NULL, v_mnemonic, "bcs", 0,   AF_REL, { 0x25 }},
  1047.     { NULL, v_mnemonic, "blo", 0,   AF_REL, { 0x25 }},
  1048.     { NULL, v_mnemonic, "beq", 0,   AF_REL, { 0x27 }},
  1049.     { NULL, v_mnemonic, "bge", 0,   AF_REL, { 0x2C }},
  1050.     { NULL, v_mnemonic, "bgt", 0,   AF_REL, { 0x2E }},
  1051.     { NULL, v_mnemonic, "bhi", 0,   AF_REL, { 0x22 }},
  1052.     { NULL, v_mnemonic, "ble", 0,   AF_REL, { 0x2F }},
  1053.     { NULL, v_mnemonic, "bls", 0,   AF_REL, { 0x23 }},
  1054.     { NULL, v_mnemonic, "blt", 0,   AF_REL, { 0x2D }},
  1055.     { NULL, v_mnemonic, "bmi", 0,   AF_REL, { 0x2B }},
  1056.     { NULL, v_mnemonic, "bne", 0,   AF_REL, { 0x26 }},
  1057.     { NULL, v_mnemonic, "bvc", 0,   AF_REL, { 0x28 }},
  1058.     { NULL, v_mnemonic, "bvs", 0,   AF_REL, { 0x29 }},
  1059.     { NULL, v_mnemonic, "bpl", 0,   AF_REL, { 0x2A }},
  1060.     { NULL, v_mnemonic, "bsr", 0,   AF_REL, { 0x8D }},
  1061.     { NULL, v_mnemonic, "clc", 0,   AF_IMP, { 0x0C }},
  1062.     { NULL, v_mnemonic, "cli", 0,   AF_IMP, { 0x0E }},
  1063.     { NULL, v_mnemonic, "clv", 0,   AF_IMP, { 0x0A }},
  1064.     { NULL, v_mnemonic, "sec", 0,   AF_IMP, { 0x0D }},
  1065.     { NULL, v_mnemonic, "sei", 0,   AF_IMP, { 0x0F }},
  1066.     { NULL, v_mnemonic, "sev", 0,   AF_IMP, { 0x0B }},
  1067.     { NULL, v_mnemonic, "tap", 0,   AF_IMP, { 0x06 }},
  1068.     { NULL, v_mnemonic, "tpa", 0,   AF_IMP, { 0x07 }},
  1069.     { NULL, v_mnemonic, "clr", 0,   AF_BYTEADRX|AF_WORDADR,
  1070.     { 0x6F, 0x7F }},
  1071.     { NULL, v_mnemonic, "clra", 0,  AF_IMP, { 0x4F }},
  1072.     { NULL, v_mnemonic, "clrb", 0,  AF_IMP, { 0x5F }},
  1073.     { NULL, v_mnemonic, "cmpa", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1074.     { 0x81, 0x91, 0xA1, 0xB1 }},
  1075.     { NULL, v_mnemonic, "cmpb", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1076.     { 0xC1, 0xD1, 0xE1, 0xF1 }},
  1077.     { NULL, v_mnemonic, "cba", 0,   AF_IMP, { 0x11 }},
  1078.     { NULL, v_mnemonic, "com", 0,   AF_BYTEADRX|AF_WORDADR,
  1079.     { 0x63, 0x73 }},
  1080.     { NULL, v_mnemonic, "coma", 0,  AF_IMP, { 0x43 }},
  1081.     { NULL, v_mnemonic, "comb", 0,  AF_IMP, { 0x53 }},
  1082.     { NULL, v_mnemonic, "neg", 0,   AF_BYTEADRX|AF_WORDADR,
  1083.     { 0x60, 0x70 }},
  1084.     { NULL, v_mnemonic, "nega", 0,  AF_IMP, { 0x40 }},
  1085.     { NULL, v_mnemonic, "negb", 0,  AF_IMP, { 0x50 }},
  1086.     { NULL, v_mnemonic, "daa", 0,   AF_IMP, { 0x19 }},
  1087.     { NULL, v_mnemonic, "dec", 0,   AF_BYTEADRX|AF_WORDADR,
  1088.     { 0x6A, 0x7A }},
  1089.     { NULL, v_mnemonic, "deca", 0,  AF_IMP, { 0x4A }},
  1090.     { NULL, v_mnemonic, "decb", 0,  AF_IMP, { 0x5A }},
  1091.     { NULL, v_mnemonic, "eora", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1092.     { 0x88, 0x98, 0xA8, 0xB8 }},
  1093.     { NULL, v_mnemonic, "eorb", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1094.     { 0xC8, 0xD8, 0xE8, 0xF8 }},
  1095.     { NULL, v_mnemonic, "inc", 0,   AF_BYTEADRX|AF_WORDADR,
  1096.     { 0x6C, 0x7C }},
  1097.     { NULL, v_mnemonic, "inca", 0,  AF_IMP, { 0x4C }},
  1098.     { NULL, v_mnemonic, "incb", 0,  AF_IMP, { 0x5C }},
  1099.     { NULL, v_mnemonic, "jmp",  0,  AF_BYTEADRX|AF_WORDADR,
  1100.     { 0x6E, 0x7E }},
  1101.     { NULL, v_mnemonic, "jsr",  0,  AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1102.     { 0x9D, 0xAD, 0xBD }},
  1103.     { NULL, v_mnemonic, "ldaa", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1104.     { 0x86, 0x96, 0xA6, 0xB6 }},
  1105.     { NULL, v_mnemonic, "ldab", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1106.     { 0xC6, 0xD6, 0xE6, 0xF6 }},
  1107.     { NULL, v_mnemonic, "ldd", 0,   AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1108.     { 0xCC, 0xDC, 0xEC, 0xFC }},
  1109.     { NULL, v_mnemonic, "mul", 0,   AF_IMP, { 0x3D }},
  1110.     { NULL, v_mnemonic, "nop", 0,   AF_IMP, { 0x01 }},
  1111.     { NULL, v_mnemonic, "oraa",0,   AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1112.     { 0x8A, 0x9A, 0xAA, 0xBA }},
  1113.     { NULL, v_mnemonic, "orab", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1114.     { 0xCA, 0xDA, 0xEA, 0xFA }},
  1115.     { NULL, v_mnemonic, "psha", 0,  AF_IMP, { 0x36 }},
  1116.     { NULL, v_mnemonic, "pshb", 0,  AF_IMP, { 0x37 }},
  1117.     { NULL, v_mnemonic, "pshx", 0,  AF_IMP, { 0x3C }},
  1118.     { NULL, v_mnemonic, "pulx", 0,  AF_IMP, { 0x38 }},
  1119.     { NULL, v_mnemonic, "pula", 0,  AF_IMP, { 0x32 }},
  1120.     { NULL, v_mnemonic, "pulb", 0,  AF_IMP, { 0x33 }},
  1121.     { NULL, v_mnemonic, "rol", 0,   AF_BYTEADRX|AF_WORDADR,
  1122.     { 0x69, 0x79 }},
  1123.     { NULL, v_mnemonic, "rola", 0,  AF_IMP, { 0x49 }},
  1124.     { NULL, v_mnemonic, "rolb", 0,  AF_IMP, { 0x59 }},
  1125.     { NULL, v_mnemonic, "ror", 0,   AF_BYTEADRX|AF_WORDADR,
  1126.     { 0x66, 0x76 }},
  1127.     { NULL, v_mnemonic, "rora", 0,  AF_IMP, { 0x46 }},
  1128.     { NULL, v_mnemonic, "rorb", 0,  AF_IMP, { 0x56 }},
  1129.     { NULL, v_mnemonic, "rti", 0,   AF_IMP, { 0x3B }},
  1130.     { NULL, v_mnemonic, "rts", 0,   AF_IMP, { 0x39 }},
  1131.     { NULL, v_mnemonic, "swi", 0,   AF_IMP, { 0x3F }},
  1132.     { NULL, v_mnemonic, "wai", 0,   AF_IMP, { 0x3E }},
  1133.     { NULL, v_mnemonic, "asl", 0,   AF_BYTEADRX|AF_WORDADR,
  1134.     { 0x68, 0x78 }},
  1135.     { NULL, v_mnemonic, "lsl", 0,   AF_BYTEADRX|AF_WORDADR,
  1136.     { 0x68, 0x78 }},
  1137.     { NULL, v_mnemonic, "asla", 0,  AF_IMP, { 0x48 }},
  1138.     { NULL, v_mnemonic, "aslb", 0,  AF_IMP, { 0x58 }},
  1139.     { NULL, v_mnemonic, "asld", 0,  AF_IMP, { 0x05 }},
  1140.     { NULL, v_mnemonic, "lsla", 0,  AF_IMP, { 0x48 }},  /* same thing */
  1141.     { NULL, v_mnemonic, "lslb", 0,  AF_IMP, { 0x58 }},
  1142.     { NULL, v_mnemonic, "lsld", 0,  AF_IMP, { 0x05 }},
  1143.     { NULL, v_mnemonic, "asr", 0,   AF_BYTEADRX|AF_WORDADR,
  1144.     { 0x67, 0x77 }},
  1145.     { NULL, v_mnemonic, "asra", 0,  AF_IMP, { 0x47 }},
  1146.     { NULL, v_mnemonic, "asrb", 0,  AF_IMP, { 0x57 }},
  1147.     { NULL, v_mnemonic, "cpx",  0,  AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1148.     { 0x8C, 0x9C, 0xAC, 0xBC }},
  1149.     { NULL, v_mnemonic, "dex", 0,   AF_IMP, { 0x09 }},
  1150.     { NULL, v_mnemonic, "des", 0,   AF_IMP, { 0x34 }},
  1151.     { NULL, v_mnemonic, "inx", 0,   AF_IMP, { 0x08 }},
  1152.     { NULL, v_mnemonic, "ins", 0,   AF_IMP, { 0x31 }},
  1153.     { NULL, v_mnemonic, "ldx", 0,   AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1154.     { 0xCE, 0xDE, 0xEE, 0xFE }},
  1155.     { NULL, v_mnemonic, "lds", 0,   AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1156.     { 0x8E, 0x9E, 0xAE, 0xBE }},
  1157.     { NULL, v_mnemonic, "lsr", 0,   AF_BYTEADRX|AF_WORDADR,
  1158.     { 0x64, 0x74 }},
  1159.     { NULL, v_mnemonic, "lsra", 0,  AF_IMP, { 0x44 }},
  1160.     { NULL, v_mnemonic, "lsrb", 0,  AF_IMP, { 0x54 }},
  1161.     { NULL, v_mnemonic, "lsrd", 0,  AF_IMP, { 0x04 }},
  1162.     { NULL, v_mnemonic, "staa", 0,  AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1163.     { 0x97, 0xA7, 0xB7 }},
  1164.     { NULL, v_mnemonic, "stab", 0,  AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1165.     { 0xD7, 0xE7, 0xF7 }},
  1166.     { NULL, v_mnemonic, "std", 0,   AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1167.     { 0xDD, 0xED, 0xFD }},
  1168.     { NULL, v_mnemonic, "sts", 0,   AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1169.     { 0x9F, 0xAF, 0xBF }},
  1170.     { NULL, v_mnemonic, "stx", 0,   AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1171.     { 0xDF, 0xEF, 0xFF }},
  1172.     { NULL, v_mnemonic, "suba", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1173.     { 0x80, 0x90, 0xA0, 0xB0 }},
  1174.     { NULL, v_mnemonic, "subb", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1175.     { 0xC0, 0xD0, 0xE0, 0xF0 }},
  1176.     { NULL, v_mnemonic, "subd", 0,  AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1177.     { 0x83, 0x93, 0xA3, 0xB3 }},
  1178.     { NULL, v_mnemonic, "sba", 0,   AF_IMP, { 0x10 }},
  1179.     { NULL, v_mnemonic, "sbca", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1180.     { 0x82, 0x92, 0xA2, 0xB2 }},
  1181.     { NULL, v_mnemonic, "sbcb", 0,  AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR,
  1182.     { 0xC2, 0xD2, 0xE2, 0xF2 }},
  1183.     { NULL, v_mnemonic, "tab", 0,   AF_IMP, { 0x16 }},
  1184.     { NULL, v_mnemonic, "tba", 0,   AF_IMP, { 0x17 }},
  1185.     { NULL, v_mnemonic, "tst", 0,   AF_BYTEADRX|AF_WORDADR,
  1186.     { 0x6D, 0x7D }},
  1187.     { NULL, v_mnemonic, "tsta", 0,  AF_IMP, { 0x4D }},
  1188.     { NULL, v_mnemonic, "tstb", 0,  AF_IMP, { 0x5D }},
  1189.     { NULL, v_mnemonic, "tsx", 0,   AF_IMP, { 0x30 }},
  1190.     { NULL, v_mnemonic, "txs", 0,   AF_IMP, { 0x35 }},
  1191.     NULL
  1192. };
  1193.  
  1194. MNE MneHD6303[] = {
  1195.     { NULL, v_mnemonic, "slp", 0,   AF_IMP, { 0x1A }},
  1196.     { NULL, v_mnemonic, "aim", 0,   AF_BYTEADR|AF_BYTEADRX,
  1197.     { 0x71, 0x61 }},
  1198.     { NULL, v_mnemonic, "oim", 0,   AF_BYTEADR|AF_BYTEADRX,
  1199.     { 0x72, 0x62 }},
  1200.     { NULL, v_mnemonic, "eim", 0,   AF_BYTEADR|AF_BYTEADRX,
  1201.     { 0x75, 0x65 }},
  1202.     { NULL, v_mnemonic, "tim", 0,   AF_BYTEADR|AF_BYTEADRX,
  1203.     { 0x7B, 0x6B }},
  1204.     { NULL, v_mnemonic, "xgdx", 0,  AF_IMP, { 0x18 }},
  1205.     NULL
  1206. };
  1207.  
  1208.  
  1209. \Rogue\Monster\
  1210. else
  1211.   echo "will not over write src/mne6303.c"
  1212. fi
  1213. if [ `wc -c src/mne6303.c | awk '{printf $1}'` -ne 9596 ]
  1214. then
  1215. echo `wc -c src/mne6303.c | awk '{print "Got " $1 ", Expected " 9596}'`
  1216. fi
  1217. if `test ! -d test`
  1218. then
  1219.   mkdir test
  1220.   echo "mkdir test"
  1221. fi
  1222. if `test ! -s test/suite6502.asm`
  1223. then
  1224. echo "writing test/suite6502.asm"
  1225. cat > test/suite6502.asm << '\Rogue\Monster\'
  1226.  
  1227.     ;   TEST ADDRESSING MODES
  1228.  
  1229.     processor   6502
  1230.  
  1231.     org    0
  1232.  
  1233.     adc    #1
  1234.     adc    1
  1235.     adc    1,x
  1236.     adc    1,y        ;absolute
  1237.     adc    1000
  1238.     adc    1000,x
  1239.     adc    1000,y
  1240.     adc    (1,x)
  1241.     adc    (1),y
  1242.  
  1243.     and    #1
  1244.     and    1
  1245.     and    1,x
  1246.     and    1,y        ;absolute
  1247.     and    1000
  1248.     and    1000,x
  1249.     and    1000,y
  1250.     and    (1,x)
  1251.     and    (1),y
  1252.  
  1253.     asl
  1254.     asl    1
  1255.     asl    1,x
  1256.     asl    1000
  1257.     asl    1000,x
  1258.  
  1259.     bcc    .
  1260.     bcs    .
  1261.     beq    .
  1262.     bit    1
  1263.     bit    1000
  1264.     bmi    .
  1265.     bne    .
  1266.     bpl    .
  1267.     brk
  1268.     bvc    .
  1269.     bvs    .
  1270.     clc
  1271.     cld
  1272.     cli
  1273.     clv
  1274.  
  1275.     cmp    #1
  1276.     cmp    1
  1277.     cmp    1,x
  1278.     cmp    1,y        ;absolute
  1279.     cmp    1000
  1280.     cmp    1000,x
  1281.     cmp    1000,y
  1282.     cmp    (1,x)
  1283.     cmp    (1),y
  1284.  
  1285.     cpx    #1
  1286.     cpx    1
  1287.     cpx    1000
  1288.  
  1289.     cpy    #1
  1290.     cpy    1
  1291.     cpy    1000
  1292.  
  1293.     dec    1
  1294.     dec    1,x
  1295.     dec    1000
  1296.     dec    1000,x
  1297.  
  1298.     dex
  1299.     dey
  1300.  
  1301.     eor    #1
  1302.     eor    1
  1303.     eor    1,x
  1304.     eor    1,y        ;absolute
  1305.     eor    1000
  1306.     eor    1000,x
  1307.     eor    1000,y
  1308.     eor    (1,x)
  1309.     eor    (1),y
  1310.  
  1311.     inc    1
  1312.     inc    1,x
  1313.     inc    1000
  1314.     inc    1000,x
  1315.  
  1316.     inx
  1317.     iny
  1318.  
  1319.     jmp    1        ;absolute
  1320.     jmp    1000
  1321.     jmp    (1)         ;absolute
  1322.     jmp    (1000)
  1323.  
  1324.     jsr    1        ;absolute
  1325.     jsr    1000
  1326.  
  1327.     lda    #1
  1328.     lda    1
  1329.     lda    1,x
  1330.     lda    1,y        ;absolute
  1331.     lda    1000
  1332.     lda    1000,x
  1333.     lda    1000,y
  1334.     lda    (1,x)
  1335.     lda    (1),y
  1336.  
  1337.     ldx    #1
  1338.     ldx    1
  1339.     ldx    1,y
  1340.     ldx    1000
  1341.     ldx    1000,y
  1342.  
  1343.     ldy    #1
  1344.     ldy    1
  1345.     ldy    1,x
  1346.     ldy    1000
  1347.     ldy    1000,x
  1348.  
  1349.     lsr
  1350.     lsr    1
  1351.     lsr    1,x
  1352.     lsr    1000
  1353.     lsr    1000,x
  1354.  
  1355.     nop
  1356.  
  1357.     ora    #1
  1358.     ora    1
  1359.     ora    1,x
  1360.     ora    1,y        ;absolute
  1361.     ora    1000
  1362.     ora    1000,x
  1363.     ora    1000,y
  1364.     ora    (1,x)
  1365.     ora    (1),y
  1366.  
  1367.     pha
  1368.     php
  1369.     pla
  1370.     plp
  1371.  
  1372.     rol
  1373.     rol    1
  1374.     rol    1,x
  1375.     rol    1000
  1376.     rol    1000,x
  1377.  
  1378.     ror
  1379.     ror    1
  1380.     ror    1,x
  1381.     ror    1000
  1382.     ror    1000,x
  1383.  
  1384.     rti
  1385.     rts
  1386.  
  1387.     sbc    #1
  1388.     sbc    1
  1389.     sbc    1,x
  1390.     sbc    1,y        ;absolute
  1391.     sbc    1000
  1392.     sbc    1000,x
  1393.     sbc    1000,y
  1394.     sbc    (1,x)
  1395.     sbc    (1),y
  1396.  
  1397.     sec
  1398.     sed
  1399.     sei
  1400.  
  1401.     sta    1
  1402.     sta    1,x
  1403.     sta    1,y        ;absolute
  1404.     sta    1000
  1405.     sta    1000,x
  1406.     sta    1000,y
  1407.     sta    (1,x)
  1408.     sta    (1),y
  1409.  
  1410.     stx    1
  1411.     stx    1,y
  1412.     stx    1000
  1413.  
  1414.     sty    1
  1415.     sty    1,x
  1416.     sty    1000
  1417.  
  1418.     tax
  1419.     tay
  1420.     tsx
  1421.     txa
  1422.     txs
  1423.     tya
  1424.  
  1425.  
  1426.  
  1427. \Rogue\Monster\
  1428. else
  1429.   echo "will not over write test/suite6502.asm"
  1430. fi
  1431. if [ `wc -c test/suite6502.asm | awk '{printf $1}'` -ne 1645 ]
  1432. then
  1433. echo `wc -c test/suite6502.asm | awk '{print "Got " $1 ", Expected " 1645}'`
  1434. fi
  1435. if `test ! -s test/suite68HC11.asm`
  1436. then
  1437. echo "writing test/suite68HC11.asm"
  1438. cat > test/suite68HC11.asm << '\Rogue\Monster\'
  1439.  
  1440.  
  1441.     ;   TEST ADDRESSING MODES
  1442.  
  1443.     processor   68HC11
  1444.  
  1445.     org    0
  1446.  
  1447.     aba
  1448.     abx
  1449.     aby
  1450.     adca    #1
  1451.     adca    1
  1452.     adca    1000
  1453.     adca    1,x
  1454.     adca    1,y
  1455.     adcb    #1
  1456.     adcb    1
  1457.     adcb    1000
  1458.     adcb    1,x
  1459.     adcb    1,y
  1460.     adda    #1
  1461.     adda    1
  1462.     adda    1000
  1463.     adda    1,x
  1464.     adda    1,y
  1465.     addb    #1
  1466.     addb    1
  1467.     addb    1000
  1468.     addb    1,x
  1469.     addb    1,y
  1470.     addd    #1000
  1471.     addd    1
  1472.     addd    1000
  1473.     addd    1,x
  1474.     addd    1,y
  1475.     anda    #1
  1476.     anda    1
  1477.     anda    1000
  1478.     anda    1,x
  1479.     anda    1,y
  1480.     andb    #1
  1481.     andb    1
  1482.     andb    1000
  1483.     andb    1,x
  1484.     andb    1,y
  1485.     asla
  1486.     aslb
  1487.     asl    1    ;extended
  1488.     asl    1000
  1489.     asl    1,x
  1490.     asl    1,y
  1491.     asld
  1492.     asra
  1493.     asrb
  1494.     asr    1    ;extended
  1495.     asr    1000
  1496.     asr    1,x
  1497.     asr    1,y
  1498.     bcc    .
  1499.     bclr    1, $11
  1500.     bclr    1,x ,$22
  1501.     bclr    1,y ,$33
  1502.     bcs    .
  1503.     beq    .
  1504.     bge    .
  1505.     bgt    .
  1506.     bhi    .
  1507.     bhs    .
  1508.     bita    #1
  1509.     bita    1
  1510.     bita    1000
  1511.     bita    1,x
  1512.     bita    1,y
  1513.     bitb    #1
  1514.     bitb    1
  1515.     bitb    1000
  1516.     bitb    1,x
  1517.     bitb    1,y
  1518.     ble    .
  1519.     blo    .
  1520.     bls    .
  1521.     blt    .
  1522.     bmi    .
  1523.     bne    .
  1524.     bpl    .
  1525.     bra    .
  1526.     brclr    1, $11, .
  1527.     brclr    1,x , $22, .
  1528.     brclr    1,y , $33, .
  1529.     brn    .
  1530.     brset    1, $11, .
  1531.     brset    1,x , $22, .
  1532.     brset    1,y , $33, .
  1533.     bset    1, $11
  1534.     bset    1,x, $22
  1535.     bset    1,y, $33
  1536.     bsr    .
  1537.     bvc    .
  1538.     bvs    .
  1539.     cba
  1540.     clc
  1541.     cli
  1542.     clra
  1543.     clrb
  1544.     clr    1        ;  extended
  1545.     clr    1000
  1546.     clr    1,x
  1547.     clr    1,y
  1548.     clv
  1549.     cmpa    #1
  1550.     cmpa    1
  1551.     cmpa    1000
  1552.     cmpa    1,x
  1553.     cmpa    1,y
  1554.     cmpb    #1
  1555.     cmpb    1
  1556.     cmpb    1000
  1557.     cmpb    1,x
  1558.     cmpb    1,y
  1559.     coma
  1560.     comb
  1561.     com    1        ;    extended
  1562.     com    1000
  1563.     com    1,x
  1564.     com    1,y
  1565.     cpd    #1        ;    16 bits
  1566.     cpd    #1000
  1567.     cpd    1
  1568.     cpd    1000
  1569.     cpd    1,x
  1570.     cpd    1,y
  1571.     cpx    #1        ;    16 bits
  1572.     cpx    #1000
  1573.     cpx    1
  1574.     cpx    1000
  1575.     cpx    1,x
  1576.     cpx    1,y
  1577.     cpy    #1        ;    16 bits
  1578.     cpy    #1000
  1579.     cpy    1
  1580.     cpy    1000
  1581.     cpy    1,x
  1582.     cpy    1,y
  1583.     daa
  1584.     deca
  1585.     decb
  1586.     dec    1        ;    extended
  1587.     dec    1000
  1588.     dec    1,x
  1589.     dec    1,y
  1590.     des
  1591.     dex
  1592.     dey
  1593.     eora    #1
  1594.     eora    1
  1595.     eora    1000
  1596.     eora    1,x
  1597.     eora    1,y
  1598.     eorb    #1
  1599.     eorb    1
  1600.     eorb    1000
  1601.     eorb    1,x
  1602.     eorb    1,y
  1603.     fdiv
  1604.     idiv
  1605.     inca
  1606.     incb
  1607.     inc    1    ;extended
  1608.     inc    1000
  1609.     inc    1,x
  1610.     inc    1,y
  1611.     ins
  1612.     inx
  1613.     iny
  1614.     jmp    1    ;extended
  1615.     jmp    1000
  1616.     jmp    1,x
  1617.     jmp    1,y
  1618.     jsr    1
  1619.     jsr    1000
  1620.     jsr    1,x
  1621.     jsr    1,y
  1622.     ldaa    #1
  1623.     ldaa    1
  1624.     ldaa    1000
  1625.     ldaa    1,x
  1626.     ldaa    1,y
  1627.     ldab    #1
  1628.     ldab    1
  1629.     ldab    1000
  1630.     ldab    1,x
  1631.     ldab    1,y
  1632.     ldd    #1    ;16 bits
  1633.     ldd    #1000
  1634.     ldd    1
  1635.     ldd    1000
  1636.     ldd    1,x
  1637.     ldd    1,y
  1638.     lds    #1    ;16 bits
  1639.     lds    #1000
  1640.     lds    1
  1641.     lds    1000
  1642.     lds    1,x
  1643.     lds    1,y
  1644.     ldx    #1    ;16 bits
  1645.     ldx    #1000
  1646.     ldx    1
  1647.     ldx    1000
  1648.     ldx    1,x
  1649.     ldx    1,y
  1650.     ldy    #1    ;16 bits
  1651.     ldy    #1000
  1652.     ldy    1
  1653.     ldy    1000
  1654.     ldy    1,x
  1655.     ldy    1,y
  1656.     lsla
  1657.     lslb
  1658.     lsl    1    ;extended
  1659.     lsl    1000
  1660.     lsl    1,x
  1661.     lsl    1,y
  1662.     lsld
  1663.     lsra
  1664.     lsrb
  1665.     lsr    1    ;extended
  1666.     lsr    1000
  1667.     lsr    1,x
  1668.     lsr    1,y
  1669.     lsrd
  1670.     mul
  1671.     nega
  1672.     negb
  1673.     neg    1    ;extended
  1674.     neg    1000
  1675.     neg    1,x
  1676.     neg    1,y
  1677.     nop
  1678.     oraa    #1
  1679.     oraa    1
  1680.     oraa    1000
  1681.     oraa    1,x
  1682.     oraa    1,y
  1683.     orab    #1
  1684.     orab    1
  1685.     orab    1000
  1686.     orab    1,x
  1687.     orab    1,y
  1688.     psha
  1689.     pshb
  1690.     pshx
  1691.     pshy
  1692.     pula
  1693.     pulb
  1694.     pulx
  1695.     puly
  1696.     rola
  1697.     rolb
  1698.     rol    1    ;extended
  1699.     rol    1000
  1700.     rol    1,x
  1701.     rol    1,y
  1702.     rora
  1703.     rorb
  1704.     ror    1    ;extended
  1705.     ror    1000
  1706.     ror    1,x
  1707.     ror    1,y
  1708.     rti
  1709.     rts
  1710.     sba
  1711.     sbca    #1
  1712.     sbca    1
  1713.     sbca    1000
  1714.     sbca    1,x
  1715.     sbca    1,y
  1716.     sbcb    #1
  1717.     sbcb    1
  1718.     sbcb    1000
  1719.     sbcb    1,x
  1720.     sbcb    1,y
  1721.     sec
  1722.     sei
  1723.     sev
  1724.     staa    1
  1725.     staa    1000
  1726.     staa    1,x
  1727.     staa    1,y
  1728.     stab    1
  1729.     stab    1000
  1730.     stab    1,x
  1731.     stab    1,y
  1732.     std    1
  1733.     std    1000
  1734.     std    1,x
  1735.     std    1,y
  1736.     stop
  1737.     sts    1
  1738.     sts    1000
  1739.     sts    1,x
  1740.     sts    1,y
  1741.     stx    1
  1742.     stx    1000
  1743.     stx    1,x
  1744.     stx    1,y
  1745.     sty    1
  1746.     sty    1000
  1747.     sty    1,x
  1748.     sty    1,y
  1749.     suba    #1
  1750.     suba    1
  1751.     suba    1000
  1752.     suba    1,x
  1753.     suba    1,y
  1754.     subb    #1
  1755.     subb    1
  1756.     subb    1000
  1757.     subb    1,x
  1758.     subb    1,y
  1759.     subd    #1    ;extended
  1760.     subd    #1000
  1761.     subd    1
  1762.     subd    1000
  1763.     subd    1,x
  1764.     subd    1,y
  1765.     swi
  1766.     tab
  1767.     tap
  1768.     tba
  1769.     test
  1770.     tpa
  1771.     tsta
  1772.     tstb
  1773.     tst    1    ;extended
  1774.     tst    1000
  1775.     tst    1,x
  1776.     tst    1,y
  1777.     tsx
  1778.     tsy
  1779.     txs
  1780.     tys
  1781.     wai
  1782.     xgdx
  1783.     xgdy
  1784.  
  1785.  
  1786.  
  1787.  
  1788.  
  1789.  
  1790.  
  1791.  
  1792.  
  1793.  
  1794.  
  1795.  
  1796.  
  1797.  
  1798. \Rogue\Monster\
  1799. else
  1800.   echo "will not over write test/suite68HC11.asm"
  1801. fi
  1802. if [ `wc -c test/suite68HC11.asm | awk '{printf $1}'` -ne 3203 ]
  1803. then
  1804. echo `wc -c test/suite68HC11.asm | awk '{print "Got " $1 ", Expected " 3203}'`
  1805. fi
  1806. if `test ! -s test/suite68705.asm`
  1807. then
  1808. echo "writing test/suite68705.asm"
  1809. cat > test/suite68705.asm << '\Rogue\Monster\'
  1810.  
  1811.     processor 68705
  1812.  
  1813.     org 0
  1814.     adc #10
  1815.     adc 10
  1816.     adc 1000
  1817.     adc ,x
  1818.     adc 1,x
  1819.     adc 1000,x
  1820.     add #10
  1821.     add 10
  1822.     add 1000
  1823.     add ,x
  1824.     add 1,x
  1825.     add 1000,x
  1826.  
  1827.     and #10
  1828.     and 10
  1829.     and 1000
  1830.     and ,x
  1831.     and 1,x
  1832.     and 1000,x
  1833.  
  1834.     asla
  1835.     aslx
  1836.     asl 10
  1837.     asl ,x
  1838.     asl 10,x
  1839.  
  1840.     asra
  1841.     asrx
  1842.     asr 10
  1843.     asr ,x
  1844.     asr 10,x
  1845.  
  1846.     bcc .
  1847.     bclr    1,23
  1848.     bcs .
  1849.     beq .
  1850.     bhcc .
  1851.     bhcs .
  1852.     bhi .
  1853.     bhs .
  1854.     bih .
  1855.     bil .
  1856.  
  1857.     bit #10
  1858.     bit 10
  1859.     bit 1000
  1860.     bit ,x
  1861.     bit 1,x
  1862.     bit 1000,x
  1863.  
  1864.     blo .
  1865.     bls .
  1866.     bmc .
  1867.     bmi .
  1868.     bms .
  1869.     bne .
  1870.     bpl .
  1871.     bra .
  1872.     brn .
  1873.     brclr    1,10,.
  1874.     brset    1,10,.
  1875.     bset    1,10
  1876.     bsr .
  1877.  
  1878.     clc
  1879.     cli
  1880.  
  1881.     clra
  1882.     clrx
  1883.     clr 10
  1884.     clr ,x
  1885.     clr 10,x
  1886.  
  1887.     cmp #10
  1888.     cmp 10
  1889.     cmp 1000
  1890.     cmp ,x
  1891.     cmp 1,x
  1892.     cmp 1000,x
  1893.  
  1894.     coma
  1895.     comx
  1896.     com 10
  1897.     com ,x
  1898.     com 10,x
  1899.  
  1900.     cpx #10
  1901.     cpx 10
  1902.     cpx 1000
  1903.     cpx ,x
  1904.     cpx 10,x
  1905.     cpx 1000,x
  1906.  
  1907.     deca
  1908.     decx
  1909.     dec 10
  1910.     dec ,x
  1911.     dec 10,x
  1912.  
  1913.     eor #10
  1914.     eor 10
  1915.     eor 1000
  1916.     eor ,x
  1917.     eor 10,x
  1918.     eor 1000,x
  1919.  
  1920.     inca
  1921.     incx
  1922.     inc 10
  1923.     inc ,x
  1924.     inc 10,x
  1925.  
  1926.     jmp 10
  1927.     jmp 1000
  1928.     jmp ,x
  1929.     jmp 10,x
  1930.     jmp 1000,x
  1931.  
  1932.     jsr 10
  1933.     jsr 1000
  1934.     jsr ,x
  1935.     jsr 10,x
  1936.     jsr 1000,x
  1937.  
  1938.     lda #10
  1939.     lda 10
  1940.     lda 1000
  1941.     lda ,x
  1942.     lda 10,x
  1943.     lda 1000,x
  1944.  
  1945.     ldx #10
  1946.     ldx 10
  1947.     ldx 1000
  1948.     ldx ,x
  1949.     ldx 10,x
  1950.     ldx 1000,x
  1951.  
  1952.     lsla
  1953.     lslx
  1954.     lsl 10
  1955.     lsl ,x
  1956.     lsl 10,x
  1957.  
  1958.     lsra
  1959.     lsrx
  1960.     lsr 10
  1961.     lsr ,x
  1962.     lsr 10,x
  1963.  
  1964.     nega
  1965.     negx
  1966.     neg 10
  1967.     neg ,x
  1968.     neg 10,x
  1969.  
  1970.     nop
  1971.  
  1972.     ora #10
  1973.     ora 10
  1974.     ora 1000
  1975.     ora ,x
  1976.     ora 10,x
  1977.     ora 1000,x
  1978.  
  1979.     rola
  1980.     rolx
  1981.     rol 10
  1982.     rol ,x
  1983.     rol 10,x
  1984.  
  1985.     rora
  1986.     rorx
  1987.     ror 10
  1988.     ror ,x
  1989.     ror 10,x
  1990.  
  1991.     rsp
  1992.     rti
  1993.     rts
  1994.  
  1995.     sbc #10
  1996.     sbc 10
  1997.     sbc 1000
  1998.     sbc ,x
  1999.     sbc 10,x
  2000.     sbc 1000,x
  2001.  
  2002.     sec
  2003.     sei
  2004.  
  2005.     sta 10
  2006.     sta 1000
  2007.     sta ,x
  2008.     sta 10,x
  2009.     sta 1000,x
  2010.  
  2011.     stx 10
  2012.     stx 1000
  2013.     stx ,x
  2014.     stx 10,x
  2015.     stx 1000,x
  2016.  
  2017.     sub #10
  2018.     sub 10
  2019.     sub 1000
  2020.     sub ,x
  2021.     sub 10,x
  2022.     sub 1000,x
  2023.  
  2024.     swi
  2025.     tax
  2026.  
  2027.     tsta
  2028.     tstx
  2029.     tst 10
  2030.     tst ,x
  2031.     tst 10,x
  2032.  
  2033.     txa
  2034.  
  2035. \Rogue\Monster\
  2036. else
  2037.   echo "will not over write test/suite68705.asm"
  2038. fi
  2039. if [ `wc -c test/suite68705.asm | awk '{printf $1}'` -ne 1628 ]
  2040. then
  2041. echo `wc -c test/suite68705.asm | awk '{print "Got " $1 ", Expected " 1628}'`
  2042. fi
  2043. if `test ! -s test/suite6303.asm`
  2044. then
  2045. echo "writing test/suite6303.asm"
  2046. cat > test/suite6303.asm << '\Rogue\Monster\'
  2047.  
  2048.     processor   hd6303
  2049.     org 0
  2050.  
  2051.     adda    #10    ;   8B 0A
  2052.     adda    10    ;   9B 0A
  2053.     adda    10,x    ;   AB 0A
  2054.     adda    1000    ;   BB 03 E8
  2055.     addb    #10    ;   CB 0A
  2056.     addb    10    ;   DB 0A
  2057.     addb    10,x    ;   EB 0A
  2058.     addb    1000    ;   FB 03 E8
  2059.     addd    #1000    ;   C3 03 E8
  2060.     addd    10    ;   D3 0A
  2061.     addd    10,x    ;   E3 0A
  2062.     addd    1000    ;   F3 03 E8
  2063.     aba        ;   1B
  2064.     adca    #10    ;   89 0A
  2065.     adca    10    ;   99 0A
  2066.     adca    10,x    ;   A9 0A
  2067.     adca    1000    ;   B9 03 E8
  2068.     adcb    #10    ;   C9
  2069.     adcb    10    ;   D9
  2070.     adcb    10,x    ;   E9
  2071.     adcb    1000    ;   F9 03 E8
  2072.     anda    #10    ;   84 0A
  2073.     anda    10    ;   94 0A
  2074.     anda    10,x    ;   A4 0A
  2075.     anda    1000    ;   B4 03 E8
  2076.     andb    #10    ;   C4 0A
  2077.     andb    10    ;   D4 0A
  2078.     andb    10,x    ;   E4 0A
  2079.     andb    1000    ;   F4 03 E8
  2080.     bita    #10    ;   85 0A
  2081.     bita    10    ;   95 0A
  2082.     bita    10,x    ;   A5 0A
  2083.     bita    1000    ;   B5 03 E8
  2084.     bitb    #10    ;   C5 0A
  2085.     bitb    10    ;   D5 0A
  2086.     bitb    10,x    ;   E5 0A
  2087.     bitb    1000    ;   F5 03 E8
  2088.     clr    10,x    ;   6F 0A
  2089.     clr    1000    ;   7F 03 E8
  2090.     clra        ;   4F
  2091.     clrb        ;   5F
  2092.     cmpa    #10    ;   81 0A
  2093.     cmpa    10    ;   91 0A
  2094.     cmpa    10,x    ;   A1 0A
  2095.     cmpa    1000    ;   B1 03 E8
  2096.     cmpb    #10    ;   C1 0A
  2097.     cmpb    10    ;   D1 0A
  2098.     cmpb    10,x    ;   E1 0A
  2099.     cmpb    1000    ;   F1 03 E8
  2100.     cba        ;   11
  2101.     com    10,x    ;   63 0A
  2102.     com    1000    ;   73 03 E8
  2103.     coma        ;   43
  2104.     comb        ;   53
  2105.     neg    10,x    ;   60 0A
  2106.     neg    1000    ;   70 03 E8
  2107.     nega        ;   40
  2108.     negb        ;   50
  2109.     daa        ;   19
  2110.     dec    10,x    ;   6A 0A
  2111.     dec    1000    ;   7A 03 E8
  2112.     deca        ;   4A
  2113.     decb        ;   5A
  2114.     eora    #10    ;   88 0A
  2115.     eora    10    ;   98 0A
  2116.     eora    10,x    ;   A8 0A
  2117.     eora    1000    ;   B8 03 E8
  2118.     eorb    #10    ;   C8 0A
  2119.     eorb    10    ;   D8 0A
  2120.     eorb    10,x    ;   E8 0A
  2121.     eorb    1000    ;   F8 03 E8
  2122.     inc    10,x    ;   6C 0A
  2123.     inc    1000    ;   7C 03 E8
  2124.     inca        ;   4C
  2125.     incb        ;   5C
  2126.     ldaa    #10    ;   86 0A
  2127.     ldaa    10    ;   96 0A
  2128.     ldaa    10,x    ;   A6 0A
  2129.     ldaa    1000    ;   B6 03 E8
  2130.     ldab    #10    ;   C6 0A
  2131.     ldab    10    ;   D6 0A
  2132.     ldab    10,x    ;   E6 0A
  2133.     ldab    1000    ;   F6 03 E8
  2134.     ldd    #1000    ;   CC 03 E8
  2135.     ldd    10    ;   DC 0A
  2136.     ldd    10,x    ;   EC 0A
  2137.     ldd    1000    ;   FC 03 E8
  2138.     mul        ;   3D
  2139.     oraa    #10    ;   8A 0A
  2140.     oraa    10    ;   9A 0A
  2141.     oraa    10,x    ;   AA 0A
  2142.     oraa    1000    ;   BA 03 E8
  2143.     orab    #10    ;   CA 0A
  2144.     orab    10    ;   DA 0A
  2145.     orab    10,x    ;   EA 0A
  2146.     orab    1000    ;   FA 03 E8
  2147.     psha        ;   36
  2148.     pshb        ;   37
  2149.     pula        ;   32
  2150.     pulb        ;   33
  2151.     rol    10,x    ;   69 0A
  2152.     rol    1000    ;   79 03 E8
  2153.     rola        ;   49
  2154.     rolb        ;   59
  2155.     ror    10,x    ;   66 0A
  2156.     ror    1000    ;   76 03 E8
  2157.     rora        ;   46
  2158.     rorb        ;   56
  2159.     asl    10,x    ;   68 0A
  2160.     asl    1000    ;   78 03 E8
  2161.     asla        ;   48
  2162.     aslb        ;   58
  2163.     asld        ;   05
  2164.     asr    10,x    ;   67 0A
  2165.     asr    1000    ;   77 03 E8
  2166.     asra        ;   47
  2167.     asrb        ;   57
  2168.     lsr    10,x    ;   64 0A
  2169.     lsr    1000    ;   74 03 E8
  2170.     lsra        ;   44
  2171.     lsrb        ;   54
  2172.     lsrd        ;   04
  2173.     staa    10    ;   97 0A
  2174.     staa    10,x    ;   A7 0A
  2175.     staa    1000    ;   B7 03 E8
  2176.     stab    10    ;   D7 0A
  2177.     stab    10,x    ;   E7 0A
  2178.     stab    1000    ;   F7 03 E8
  2179.     std    10    ;   DD 0A
  2180.     std    10,x    ;   ED 0A
  2181.     std    1000    ;   FD 03 E8
  2182.     suba    #10    ;   80 0A
  2183.     suba    10    ;   90 0A
  2184.     suba    10,x    ;   A0 0A
  2185.     suba    1000    ;   B0 03 E8
  2186.     subb    #10    ;   C0 0A
  2187.     subb    10    ;   D0 0A
  2188.     subb    10,x    ;   E0 0A
  2189.     subb    1000    ;   F0 03 E8
  2190.     subd    #1000    ;   83 03 E8
  2191.     subd    10    ;   93 0A
  2192.     subd    10,x    ;   A3 0A
  2193.     subd    1000    ;   B3 03 E8
  2194.     sba        ;   10
  2195.     sbca    #10    ;   82 0A
  2196.     sbca    10    ;   92 0A
  2197.     sbca    10,x    ;   A2 0A
  2198.     sbca    1000    ;   B2 03 E8
  2199.     sbcb    #10    ;   C2 0A
  2200.     sbcb    10    ;   D2 0A
  2201.     sbcb    10,x    ;   E2 0A
  2202.     sbcb    1000    ;   F2 03 E8
  2203.     tab        ;   16
  2204.     tba        ;   17
  2205.     tst    10,x    ;   6D 0A
  2206.     tst    1000    ;   7D 03 E8
  2207.     tsta        ;   4D
  2208.     tstb        ;   5D
  2209.     aim    10    ;   71 0A
  2210.     aim    10,x    ;   61 0A
  2211.     oim    10    ;   72 0A
  2212.     oim    10,x    ;   62 0A
  2213.     eim    10    ;   75 0A
  2214.     eim    10,x    ;   65 0A
  2215.     tim    10    ;   7B 0A
  2216.     tim    10,x    ;   6B 0A
  2217.     cpx    #1000    ;   8C 03 E8
  2218.     cpx    10    ;   9C 0A
  2219.     cpx    10,x    ;   AC 0A
  2220.     cpx    1000    ;   BC 03 E8
  2221.     dex        ;   09
  2222.     des        ;   34
  2223.     inx        ;   08
  2224.     ins        ;   31
  2225.     ldx    #1000    ;   CE 03 E8
  2226.     ldx    10    ;   DE 0A
  2227.     ldx    10,x    ;   EE 0A
  2228.     ldx    1000    ;   FE 03 E8
  2229.     lds    #1000    ;   8E 03 E8
  2230.     lds    10    ;   9E 0A
  2231.     lds    10,x    ;   AE 0A
  2232.     lds    1000    ;   BE 03 E8
  2233.     stx    10    ;   DF 0A
  2234.     stx    10,x    ;   EF 0A
  2235.     stx    1000    ;   FF 03 E8
  2236.     sts    10    ;   9F 0A
  2237.     sts    10,x    ;   AF 0A
  2238.     sts    1000    ;   BF 03 E8
  2239.     txs        ;   35
  2240.     tsx        ;   30
  2241.     abx        ;   3A
  2242.     pshx        ;   3C
  2243.     pulx        ;   38
  2244.     xgdx        ;   18
  2245.     bra    .    ;   20 FE
  2246.     brn    .    ;   21 FE
  2247.     bcc    .    ;   24 FE
  2248.     bcs    .    ;   25 FE
  2249.     beq    .    ;   27 FE
  2250.     bge    .    ;   2C FE
  2251.     bgt    .    ;   2E FE
  2252.     bhi    .    ;   22 FE
  2253.     ble    .    ;   2F FE
  2254.     bls    .    ;   23 FE
  2255.     blt    .    ;   2D FE
  2256.     bmi    .    ;   2B FE
  2257.     bne    .    ;   26 FE
  2258.     bvc    .    ;   28 FE
  2259.     bvs    .    ;   29 FE
  2260.     bpl    .    ;   2A FE
  2261.     bsr    .    ;   8D FE
  2262.     jmp    10,x    ;   6E 0A
  2263.     jmp    1000    ;   7E 03 E8
  2264.     jsr    10    ;   9D 0A
  2265.     jsr    10,x    ;   AD 0A
  2266.     jsr    1000    ;   BD 03 E8
  2267.     nop        ;   01
  2268.     rti        ;   3B
  2269.     rts        ;   39
  2270.     swi        ;   3F
  2271.     wai        ;   3E
  2272.     slp        ;   1A
  2273.     clc        ;   0C
  2274.     cli        ;   0E
  2275.     clv        ;   0A
  2276.     sec        ;   0D
  2277.     sei        ;   0F
  2278.     sev        ;   0B
  2279.     tap        ;   06
  2280.     tpa        ;   07
  2281.  
  2282. \Rogue\Monster\
  2283. else
  2284.   echo "will not over write test/suite6303.asm"
  2285. fi
  2286. if [ `wc -c test/suite6303.asm | awk '{printf $1}'` -ne 4346 ]
  2287. then
  2288. echo `wc -c test/suite6303.asm | awk '{print "Got " $1 ", Expected " 4346}'`
  2289. fi
  2290. if `test ! -s test/example.asm`
  2291. then
  2292. echo "writing test/example.asm"
  2293. cat > test/example.asm << '\Rogue\Monster\'
  2294.  
  2295. ;   EXAMPLE.ASM     (6502 Microprocessor)
  2296. ;
  2297.  
  2298.         processor    6502
  2299.  
  2300.         mac     ldax
  2301.         lda     [{1}]
  2302.         ldx     [{1}]+1
  2303.         endm
  2304.         mac     ldaxi
  2305.         lda     #<[{1}]
  2306.         ldx     #>[{1}]
  2307.         endm
  2308.         mac     stax
  2309.         sta     [{1}]
  2310.         stx     [{1}]+1
  2311.         endm
  2312.         mac     pushxy
  2313.         txa
  2314.         pha
  2315.         tya
  2316.         pha
  2317.         endm
  2318.         mac     popxy
  2319.         pla
  2320.         tay
  2321.         pla
  2322.         tax
  2323.         endm
  2324.         mac     inc16
  2325.         inc     {1}
  2326.         bne     .1
  2327.         inc     {1}+1
  2328. .1
  2329.         endm
  2330.  
  2331. STOP1        equ %00000000        ;CxCTL  1 Stop bit
  2332. STOP2        equ %10000000        ;CxCTL  2 Stop bits (WL5:1.5, WL8&par:1)
  2333. WL5        equ %01100000        ;CxCTL  Wordlength
  2334. WL6        equ %01000000
  2335. WL7        equ %00100000
  2336. WL8        equ %00000000
  2337. RCS        equ %00010000        ;CxCTL  1=Select baud, 0=ext. receiver clk
  2338.  
  2339. B76800        equ %0000            ;CxCTL  Baud rates    (1.2288 Mhz clock)
  2340. B75        equ %0001
  2341. B100        equ %0010
  2342. B150        equ %0011
  2343. B200        equ %0100
  2344. B300        equ %0101
  2345. B400        equ %0110
  2346. B600        equ %0111
  2347. B800        equ %1000
  2348. B1200        equ %1001
  2349. B1600        equ %1010
  2350. B2400        equ %1011
  2351. B3200        equ %1100
  2352. B4800        equ %1101
  2353. B6400        equ %1110
  2354. B12800        equ %1111
  2355.  
  2356. PARODD        equ %00100000        ;CxCMD  Select Parity
  2357. PAREVEN     equ %01100000
  2358. PARMARK     equ %10100000
  2359. PARSPACE    equ %11100000
  2360. PAROFF        equ %00000000
  2361.  
  2362. RECECHO     equ %00010000        ;CxCMD  Receiver Echo mode
  2363. TMASK        equ %00001100
  2364. TDISABLE    equ %00000000        ;CxCMD  Transmitter modes
  2365. TDISABLER   equ %00001000        ;RTS stays asserted
  2366. TENABLE     equ %00000100
  2367. TBREAK        equ %00001100        ;send break
  2368.  
  2369. UA_IRQDSBL  equ %00000010
  2370. DTRRDY        equ %00000001        ;~DTR output is inverted (low)
  2371.  
  2372. SR_PE        equ %00000001        ;CxSTAT  Status
  2373. SR_FE        equ %00000010        ;NOTE: writing dummy data causes RESET
  2374. SR_OVRUN    equ %00000100
  2375. SR_RDRFULL  equ %00001000
  2376. SR_TDREMPTY equ %00010000
  2377. SR_DCD        equ %00100000
  2378. SR_DSR        equ %01000000
  2379. SR_INTPEND  equ %10000000
  2380.  
  2381.  
  2382. T1_OEPB7    equ %10000000        ;x_ACR
  2383. T1_FREERUN  equ %01000000        ;T1 free running mode
  2384. T1_ONESHOT  equ %00000000
  2385. T2_ICPB6    equ %00100000        ;T2 counts pulses on PB6
  2386. T2_ONESHOT  equ %00000000        ;T2 counts phase2 transitions
  2387. SRC_OFF     equ %00000000        ;shift register control
  2388. SRC_INT2    equ %00000100
  2389. SRC_INPH2   equ %00001000
  2390. SRC_INEXT   equ %00001100
  2391. SRC_OUTFR   equ %00010000        ;free running output using T2
  2392. SRC_OUTT2   equ %00010100
  2393. SRC_OUTPH2  equ %00011000
  2394. SRC_OUTEXT  equ %00011100
  2395. PBLE        equ %00000010        ;on CB1 transition (in/out).
  2396. PALE        equ %00000001        ;on CA1 transition (in).  data retained
  2397.  
  2398.                     ;x_PCR
  2399. CB2_I_NEG   equ %00000000        ;interrupt on neg trans, r/w ORB clears
  2400. CB2_I_NEGI  equ %00100000        ; same, but r/w ORB does not clear int
  2401. CB2_I_POS   equ %01000000        ;interrupt on pos trans, r/w ORB clears
  2402. CB2_I_POSI  equ %01100000        ; same, but r/w ORB does not clear int
  2403. CB2_O_HSHAK equ %10000000        ;CB2=0 on r/w ORB, CB2=1 on CB1 transition
  2404. CB2_O_PULSE equ %10100000        ;CB2=0 for one clock after r/w ORB
  2405. CB2_O_MANLO equ %11000000        ;CB2=0
  2406. CB2_O_MANHI equ %11100000        ;CB2=1
  2407.  
  2408. CA2_I_NEG   equ %00000000        ;interrupt on neg trans, r/w ORA clears
  2409. CA2_I_NEGI  equ %00100000        ; same, but r/w ORA does not clear int
  2410. CA2_I_POS   equ %01000000        ;interrupt on pos trans, r/w ORA clears
  2411. CA2_I_POSI  equ %01100000        ; same, but r/w ORA does not clear int
  2412. CA2_O_HSHAK equ %10000000        ;CA2=0 on r/w ORA, CA2=1 on CA1 transition
  2413. CA2_O_PULSE equ %10100000        ;CA2=0 for one clock after r/w ORA
  2414. CA2_O_MANLO equ %11000000        ;CA2=0
  2415. CA2_O_MANHI equ %11100000        ;CA2=1
  2416.  
  2417.  
  2418. CB1_THI     equ %00010000
  2419. CB1_TLO     equ %00000000
  2420. CA1_THI     equ %00000001
  2421. CA1_TLO     equ %00000000
  2422.  
  2423. VIRPEND     equ %10000000        ;x_IFR
  2424. IRENABLE    equ %10000000        ;x_IER  1's enable ints  0=no change
  2425. IRDISABLE   equ %00000000        ;x_IER  1's disable ints 0=no change
  2426.  
  2427. IRT1        equ %01000000
  2428. IRT2        equ %00100000
  2429. IRCB1        equ %00010000
  2430. IRCB2        equ %00001000
  2431. IRSR        equ %00000100
  2432. IRCA1        equ %00000010
  2433. IRCA2        equ %00000001
  2434.  
  2435.         seg.u   bss
  2436.         org     $0000        ;RAM (see below)
  2437.         org     $2000        ;unused
  2438.         org     $4000        ;unused
  2439.  
  2440.         org     $6000        ;6551 CHANNEL #1
  2441. C1DATA        ds        1
  2442. C1STAT        ds        1
  2443. C1CMD        ds        1
  2444. C1CTL        ds        1
  2445.  
  2446.         org     $8000        ;6551 CHANNEL #2
  2447. C2DATA        ds        1
  2448. C2STAT        ds        1
  2449. C2CMD        ds        1
  2450. C2CTL        ds        1
  2451.  
  2452.         org     $A000        ;6522 (HOST COMM)
  2453. H_ORB        ds        1
  2454. H_ORAHS     ds        1            ;with CA2 handshake
  2455. H_DDRB        ds        1
  2456. H_DDRA        ds        1
  2457. H_T1CL        ds        1            ;read clears interrupt flag
  2458. H_T1CH        ds        1            ;write clears interrupt flag
  2459. H_T1CLL     ds        1
  2460. H_T1CHL     ds        1            ;write clears interrupt flag
  2461. H_T2CL        ds        1            ;read clears interrupt flag
  2462. H_T2CH        ds        1            ;write clears interrupt flag
  2463. H_SR        ds        1
  2464. H_ACR        ds        1
  2465. H_PCR        ds        1
  2466. H_IFR        ds        1
  2467. H_IER        ds        1
  2468. H_ORA        ds        1            ds        1
  2469. I_T2CL        ds        1
  2470. I_T2CH        ds        1
  2471. I_SR        ds        1
  2472. I_ACR        ds        1
  2473. I_PCR        ds        1
  2474. I_IFR        ds        1
  2475. I_IER        ds        1
  2476. I_ORA        ds        1
  2477.  
  2478.  
  2479.  
  2480.         ;    ----------------------    ds        1
  2481. I_T1CLL     ds        1
  2482. I_T1CHL     ds        1
  2483. I_T2CL        ds        1
  2484. I_T2CH        ds        1
  2485. I_SR        ds        1
  2486. I_ACR        ds        1
  2487. I_PCR        ds        1
  2488. I_IFR        ds        1
  2489. I_IER        ds        1
  2490. I_ORA        ds        1
  2491.  
  2492.  
  2493.  
  2494.         ;    --------------------------   ZERO PAGE     -------------------
  2495.         seg.u   data
  2496.         org     $00
  2497.  
  2498.         ;    --------------------------  NORMAL RAM     -------------------
  2499.         org     $0100
  2500.  
  2501. RAMEND        equ     $2000
  2502.  
  2503.         ;    --------------------------     CODE     -------------------
  2504.  
  2505.         seg     code
  2506.         org     $F000
  2507. PROMBEG     equ     .
  2508.  
  2509. RESET        subroutine
  2510.         sei         ;disable interrupts
  2511.         ldx     #$FF    ;reset stack
  2512.         txs
  2513.  
  2514.         lda     #$FF
  2515.         sta     H_DDRA
  2516.         sta     C1STAT    ;reset 6551#1 (garbage data)
  2517.         sta     C2STAT    ;reset 6551#2
  2518.         lda     #$7F    ;disable all 6522 interrupts
  2519.         sta     H_IER
  2520.         sta     I_IER
  2521.  
  2522.         lda     #%00010000    ;76.8 baud, 8 bits, 1 stop
  2523.         sta     C1CTL
  2524.         lda     #%00000101    ;no parity, enable transmitter & int
  2525.         sta     C1CMD
  2526.         lda     #$AA    ;begin transmision
  2527.         sta     C1DATA
  2528.  
  2529.         lda     #%00011111    ;9600 baud, 8 bits, 1 stop
  2530.         sta     C2CTL
  2531.         lda     #%00000101
  2532.         sta     C2CMD
  2533.         lda     #$41
  2534.         sta     C2DATA
  2535.  
  2536.         cli         ;enable interrupts
  2537.  
  2538. .1        jsr     LOAD
  2539.         jsr     SAVE
  2540.         jmp     .1
  2541.  
  2542. LOAD        subroutine
  2543.  
  2544.         ldx     #0
  2545. .1        txa
  2546.         sta     $0500,x
  2547.         inx
  2548.         bne     .1
  2549.         rts
  2550.  
  2551. SAVE        subroutine
  2552.  
  2553.         ldx     #0
  2554. .2        lda     $0500,x
  2555.         sta     H_ORA
  2556.         inx
  2557.         bne     .2
  2558.         rts
  2559.  
  2560. NMI        rti
  2561.  
  2562.         subroutine
  2563. IRQ        bit     C1STAT
  2564.         bpl     .1
  2565.         pha
  2566.         lda     #$AA
  2567.         sta     C1DATA
  2568.         lda     C1DATA
  2569.         pla
  2570.         rti
  2571. .1        bit     C2STAT
  2572.         bpl     .2
  2573.         pha
  2574.         lda     #$41
  2575.         sta     C2DATA
  2576.         lda     C2DATA
  2577.         pla
  2578. .2        rti
  2579.  
  2580.         ;    VECTOR    ------------------------------------------------
  2581.  
  2582.         seg     vector
  2583.         org     $FFFA
  2584.         dc.w    NMI
  2585.         dc.w    RESET
  2586.         dc.w    IRQ
  2587.  
  2588. PROMEND     equ     .
  2589.  
  2590.  
  2591. \Rogue\Monster\
  2592. else
  2593.   echo "will not over write test/example.asm"
  2594. fi
  2595. if [ `wc -c test/example.asm | awk '{printf $1}'` -ne 7052 ]
  2596. then
  2597. echo `wc -c test/example.asm | awk '{print "Got " $1 ", Expected " 7052}'`
  2598. fi
  2599. echo "Finished archive 1 of 3"
  2600. # if you want to concatenate archives, remove anything after this line
  2601. exit
  2602. -- 
  2603. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  2604. Have five nice days.
  2605.